/**示例说明：
 * 本示例文件说明了一些js文件调用方式、脚本编写规则，
 * 以axios网络请求为切入点，几个示例让你掌握本工具的JS执行器使用方式，可用于数据对接模块的调试
 * */
////import axios from 'axios'
var axios = require('axios')
/**一个http请求实例 */
const Axios = axios.create({
    //传入url为完全url时，baseURL失效
    baseURL: 'http://localhost:5000',
    timeout: 4000
})
/**另一个http请求实例，备用 */
const instance = axios.create({
    baseURL: 'http://localhost:4000',
    timeout: 2000,
});

// 在发送请求之前做某件事，自己按照需求修改
Axios.interceptors.request.use(config => {
    // 设置以 form 表单的形式提交参数，如果以 JSON 的形式提交表单，可忽略
    // if (config.method === 'post') {
    //     // JSON 转换为 FormData
    //     const formData = new FormData()
    //     Object.keys(config.data).forEach(key => formData.append(key, config.data[key]))
    //     config.data = formData
    // }

    // 可以做设置header参数等操作，比如携带token

    //一般发文件时候
    if (config.responseType === 'blob') {
    /*  config.headers= {
            'Content-Type': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
        } */
    }
        return config
    }, error => {
    return Promise.reject(error)
})

// 返回状态判断(添加响应拦截器),自己按照需求修改
Axios.interceptors.response.use(res => {

  if (res.config.responseType === 'blob') { return res }
  return res.data
    //return res
}, error => {
  let errorMsg = ''
  if (error.message.includes('timeout')) {
    errorMsg = '请求超时!'
  } else {
    errorMsg = '请求异常!'
  }
  //return Promise.resolve({ Success: false, Msg: errorMsg })
    return Promise.resolve(res)
})

/**
 * 自写的数据提交函数，供引用
 * @param {string} methodurl 请求url
 * @param {any} param 请求参数
 */
function handleSubmit(methodurl, param) {
    //Axios.post('/Base_Manage/Home/SubmitLogin', values).then(resJson => {
    return new Promise((resolve, reject) => {
        Axios.post(methodurl, param).then(resJson => {
            resolve({ ResJson: '请求收到含参post请求数据~：' + JSON.stringify(resJson) })
        }).catch(err => {
            reject(JSON.stringify(err))
        })
    });
}

//
/**入口模块函数，根据函数名调用
 * 带有async的是异步调用，返回值不用callback,但若是包含一部操作，请务必使用Promise，如Axios请求，实例中有做说明
 * 返回要匹配C#中的接收，为了避免麻烦，我这里统一处理成了字符串参数传入与字符串返回，使用者可根据自己需求来，扩展对应源码即可
 * */
module.exports = {
    /**
     * 同步调用的基本示例,给输入字符串附加一个字符（串）后返回
     * @param {any} callback 同步调用时候的回调函数,无需传入，返回时调用，第一个参数为null，第二个参数为返回值/对象
     * @param {string} message 传入参数
     */
    test: (callback, message) => callback(null, { ResJson: message + '.' }),
    /**
     * 异步调用的基本示例，计算两个数之和，无异步操作，无需使用Promise
     * @param {number} c1
     * @param {number} c2
     */
    testAsync: async (c1, c2) => {
        return { ResJson: (c1 + c2).toString() }
    },
    test2: (callback) => {
        instance({
            method: 'post',
            url: '/dujitang?api_key=0b90a0abc125a393',
            //data: {
            //    firstName: 'Fred',
            //    lastName: 'Flintstone'
            //}
        })
            .then(function (response) {
                callback(null, { ResJson: '请求收到tu数据' + '：' + JSON.stringify(response) })
            })
            .catch(function (error) {
                callback(null, { ResJson: '请求收到tu数据错误' + '：' + JSON.stringify(error) })
            });
       
    },
    /**
     * 同步post请求示例
     * @param {any} callback 同步调用时候的回调函数,无需传入，返回时调用，第一个参数为null，第二个参数为返回值/对象
     * @param {any} url 请求url
     * @param {any} parmsJson 传入参数，json字符串
     */
    post: (callback, url, parmsJson) => {
        if (!url) {
            callback(null, { ResJson: 'url为空' })
            return
        }
        if (!parmsJson) {
            callback(null, { ResJson: 'parmsJson为空' })
            return
        }
        let enity = JSON.parse(parmsJson)
        
        if (parmsJson) {
            Axios.post(url, enity).then(resJson => {
                callback(null, { ResJson: '请求收到含参post请求数据：' + JSON.stringify(resJson) })
            })
        }
        else if (!parmsJson) {
            Axios.post(p1).then(resJson => {
                callback(null, { ResJson: '请求收到不含参post请求数据2：' + JSON.stringify(resJson) })
            })
        }
       
    },
    /**
     * 异步post请求示例，有异步操作，需使用Promise
     * @param {any} url 请求url
     * @param {any} parmsJson 传入参数，json字符串
     */
    postAsync: async (url, parmsJson) => {
        return new Promise((resolve, reject) => {
            if (!url) {
                reject('url为空' )
            }
            if (!parmsJson) {
                reject('parmsJson为空')
            }
            let enity = JSON.parse(parmsJson)

            if (parmsJson) {
                Axios.post(url, enity).then(resJson => {
                    resolve({ ResJson: '请求收到含参post请求数据：' + JSON.stringify(resJson) })
                }).catch(err => {
                    reject(JSON.stringify(err))
                })
            }
            else if (!parmsJson) {
                Axios.post(p1).then(resJson => {
                    resolve({ ResJson: '请求收到不含参post请求数据2：' + JSON.stringify(resJson) })
                }).catch(err => {
                    reject(JSON.stringify(err))
                })
            }
        });
    },
    /**
     * 同步get请求示例
     * @param {any} callback 同步调用时候的回调函数,无需传入，返回时调用，第一个参数为null，第二个参数为返回值/对象
     * @param {any} url 请求url
     */
    get: (callback, url) => {
        if (!url) {
            callback(null, { ResJson: 'url为空' })
            return
        }
        Axios.get(url).then(resJson => {
            callback(null, { ResJson: '请求收到get数据：' + JSON.stringify(resJson) })
        })
    },
    /**
     * 异步get请求示例，有异步操作，需使用Promise
     * @param {any} url 请求url
     */
    getAsync: async (url) => {
        return new Promise((resolve, reject) => {
            if (!url) {
                reject('url为空')
            }
            Axios.get(url).then(resJson => {
                resolve({ ResJson: '请求收到get数据：' + JSON.stringify(resJson) })
            }).catch(err => {
                reject(JSON.stringify(err))
            })
        });
    },
    /**
     * 自写异步请求示例，引用的函数方法本身以Promise化，可以直接返回
     * @param {any} url 请求url
     * @param {any} parmsJson 传入参数，json字符串
     */
    request: async (url, parmsJson) => {
        return handleSubmit(url, JSON.parse(parmsJson))
    }
}